home *** CD-ROM | disk | FTP | other *** search
- # Source Generated with Decompyle++
- # File: in.pyc (Python 2.4)
-
- from test.test_support import verify, verbose, TestFailed, fcmp
- from string import join
- from random import random, randint
- SHIFT = 15
- BASE = 2 ** SHIFT
- MASK = BASE - 1
- KARATSUBA_CUTOFF = 70
- MAXDIGITS = 15
- special = map(long, [
- 0,
- 1,
- 2,
- BASE,
- BASE >> 1])
- special.append(0x5555555555555555L)
- special.append(0xAAAAAAAAAAAAAAAAL)
- p2 = 0x4L
- for i in range(2 * SHIFT):
- special.append(p2 - 1)
- p2 = p2 << 1
-
- del p2
- special = special + map((lambda x: ~x), special) + map((lambda x: -x), special)
-
- def check(ok, *args):
- if not ok:
- raise TestFailed, join(map(str, args), ' ')
-
-
-
- def getran(ndigits):
- verify(ndigits > 0)
- nbits_hi = ndigits * SHIFT
- nbits_lo = (nbits_hi - SHIFT) + 1
- answer = 0x0L
- nbits = 0
- r = int(random() * SHIFT * 2) | 1
- while nbits < nbits_lo:
- bits = (r >> 1) + 1
- bits = min(bits, nbits_hi - nbits)
- None(verify if bits <= bits else bits <= SHIFT)
- nbits = nbits + bits
- answer = answer << bits
- if r & 1:
- answer = answer | (1 << bits) - 1
-
- r = int(random() * SHIFT * 2)
- None(verify if nbits <= nbits else nbits <= nbits_hi)
- if random() < 0.5:
- answer = -answer
-
- return answer
-
-
- def getran2(ndigits):
- answer = 0x0L
- for i in range(ndigits):
- answer = answer << SHIFT | randint(0, MASK)
-
- if random() < 0.5:
- answer = -answer
-
- return answer
-
-
- def test_division_2(x, y):
- (q, r) = divmod(x, y)
- q2 = x // y
- r2 = x % y
- pab = x * y
- pba = y * x
- check(pab == pba, 'multiplication does not commute for', x, y)
- check(q == q2, 'divmod returns different quotient than / for', x, y)
- check(r == r2, 'divmod returns different mod than % for', x, y)
- check(x == q * y + r, 'x != q*y + r after divmod on', x, y)
- if y > 0:
- None(check if r <= r else r < y, 'bad mod from divmod on', x, y)
- elif r < r:
- pass
-
- check(r <= 0, 'bad mod from divmod on', x, y)
-
-
- def test_division(maxdigits = MAXDIGITS):
- if verbose:
- print 'long / * % divmod'
-
- digits = range(1, maxdigits + 1) + range(KARATSUBA_CUTOFF, KARATSUBA_CUTOFF + 14)
- digits.append(KARATSUBA_CUTOFF * 3)
- for lenx in digits:
- x = getran(lenx)
- for leny in digits:
- if not getran(leny):
- pass
- y = 0x1L
- test_division_2(x, y)
-
-
-
-
- def test_karatsuba():
- if verbose:
- print 'Karatsuba'
-
- digits = range(1, 5) + range(KARATSUBA_CUTOFF, KARATSUBA_CUTOFF + 10)
- digits.extend([
- KARATSUBA_CUTOFF * 10,
- KARATSUBA_CUTOFF * 100])
- bits = [ digit * SHIFT for digit in digits ]
- for abits in bits:
- a = (0x1L << abits) - 1
- for bbits in bits:
- b = (0x1L << bbits) - 1
- x = a * b
- y = ((0x1L << abits + bbits) - (0x1L << abits) - (0x1L << bbits)) + 1
- check(x == y, 'bad result for', a, '*', b, x, y)
-
-
-
-
- def test_bitop_identities_1(x):
- check(x & 0 == 0, 'x & 0 != 0 for', x)
- check(x | 0 == x, 'x | 0 != x for', x)
- check(x ^ 0 == x, 'x ^ 0 != x for', x)
- check(x & -1 == x, 'x & -1 != x for', x)
- check(x | -1 == -1, 'x | -1 != -1 for', x)
- check(x ^ -1 == ~x, 'x ^ -1 != ~x for', x)
- check(x == ~~x, 'x != ~~x for', x)
- check(x & x == x, 'x & x != x for', x)
- check(x | x == x, 'x | x != x for', x)
- check(x ^ x == 0, 'x ^ x != 0 for', x)
- check(x & ~x == 0, 'x & ~x != 0 for', x)
- check(x | ~x == -1, 'x | ~x != -1 for', x)
- check(x ^ ~x == -1, 'x ^ ~x != -1 for', x)
- None(check if 1 + ~x == 1 + ~x else 1 + ~x == ~(x - 1), 'not -x == 1 + ~x == ~(x-1) for', x)
- for n in range(2 * SHIFT):
- p2 = 0x2L ** n
- check(x << n >> n == x, 'x << n >> n != x for', x, n)
- check(x // p2 == x >> n, 'x // p2 != x >> n for x n p2', x, n, p2)
- check(x * p2 == x << n, 'x * p2 != x << n for x n p2', x, n, p2)
- None(check if (x >> n) << n == (x >> n) << n else (x >> n) << n == x & ~(p2 - 1), 'not x & -p2 == x >> n << n == x & ~(p2 - 1) for x n p2', x, n, p2)
-
-
-
- def test_bitop_identities_2(x, y):
- check(x & y == y & x, 'x & y != y & x for', x, y)
- check(x | y == y | x, 'x | y != y | x for', x, y)
- check(x ^ y == y ^ x, 'x ^ y != y ^ x for', x, y)
- check(x ^ y ^ x == y, 'x ^ y ^ x != y for', x, y)
- check(x & y == ~(~x | ~y), 'x & y != ~(~x | ~y) for', x, y)
- check(x | y == ~(~x & ~y), 'x | y != ~(~x & ~y) for', x, y)
- check(x ^ y == (x | y) & ~(x & y), 'x ^ y != (x | y) & ~(x & y) for', x, y)
- check(x ^ y == x & ~y | ~x & y, 'x ^ y == (x & ~y) | (~x & y) for', x, y)
- check(x ^ y == (x | y) & (~x | ~y), 'x ^ y == (x | y) & (~x | ~y) for', x, y)
-
-
- def test_bitop_identities_3(x, y, z):
- check(x & y & z == x & y & z, '(x & y) & z != x & (y & z) for', x, y, z)
- check(x | y | z == x | y | z, '(x | y) | z != x | (y | z) for', x, y, z)
- check(x ^ y ^ z == x ^ y ^ z, '(x ^ y) ^ z != x ^ (y ^ z) for', x, y, z)
- check(x & (y | z) == x & y | x & z, 'x & (y | z) != (x & y) | (x & z) for', x, y, z)
- check(x | y & z == (x | y) & (x | z), 'x | (y & z) != (x | y) & (x | z) for', x, y, z)
-
-
- def test_bitop_identities(maxdigits = MAXDIGITS):
- if verbose:
- print 'long bit-operation identities'
-
- for x in special:
- test_bitop_identities_1(x)
-
- digits = range(1, maxdigits + 1)
- for lenx in digits:
- x = getran(lenx)
- test_bitop_identities_1(x)
- for leny in digits:
- y = getran(leny)
- test_bitop_identities_2(x, y)
- test_bitop_identities_3(x, y, getran((lenx + leny) // 2))
-
-
-
-
- def slow_format(x, base):
- if (x, base) == (0, 8):
- return '0L'
-
- digits = []
- sign = 0
- if x < 0:
- sign = 1
- x = -x
-
- while x:
- (x, r) = divmod(x, base)
- digits.append(int(r))
- digits.reverse()
- if not digits:
- pass
- digits = [
- 0]
- return '-'[:sign] + {
- 8: '0',
- 10: '',
- 16: '0x' }[base] + join(map((lambda i: '0123456789ABCDEF'[i]), digits), '') + 'L'
-
-
- def test_format_1(x):
- atol = atol
- import string
- for base, mapper in ((8, oct), (10, repr), (16, hex)):
- got = mapper(x)
- expected = slow_format(x, base)
- check(got == expected, mapper.__name__, 'returned', got, 'but expected', expected, 'for', x)
- check(atol(got, 0) == x, 'atol("%s", 0) !=' % got, x)
-
- got = str(x)
- expected = slow_format(x, 10)[:-1]
- check(got == expected, mapper.__name__, 'returned', got, 'but expected', expected, 'for', x)
-
-
- def test_format(maxdigits = MAXDIGITS):
- if verbose:
- print 'long str/hex/oct/atol'
-
- for x in special:
- test_format_1(x)
-
- for i in range(10):
- for lenx in range(1, maxdigits + 1):
- x = getran(lenx)
- test_format_1(x)
-
-
-
-
- def test_misc(maxdigits = MAXDIGITS):
- if verbose:
- print 'long miscellaneous operations'
-
- import sys
- hugepos = sys.maxint
- hugeneg = -hugepos - 1
- hugepos_aslong = long(hugepos)
- hugeneg_aslong = long(hugeneg)
- check(hugepos == hugepos_aslong, 'long(sys.maxint) != sys.maxint')
- check(hugeneg == hugeneg_aslong, 'long(-sys.maxint-1) != -sys.maxint-1')
-
- try:
- check(int(hugepos_aslong) == hugepos, 'converting sys.maxint to long and back to int fails')
- except OverflowError:
- raise TestFailed, 'int(long(sys.maxint)) overflowed!'
-
-
- try:
- check(int(hugeneg_aslong) == hugeneg, 'converting -sys.maxint-1 to long and back to int fails')
- except OverflowError:
- raise TestFailed, 'int(long(-sys.maxint-1)) overflowed!'
-
- x = hugepos_aslong + 1
-
- try:
- y = int(x)
- except OverflowError:
- raise TestFailed, "int(long(sys.maxint) + 1) mustn't overflow"
-
- if not isinstance(y, long):
- raise TestFailed('int(long(sys.maxint) + 1) should have returned long')
-
- x = hugeneg_aslong - 1
-
- try:
- y = int(x)
- except OverflowError:
- raise TestFailed, "int(long(-sys.maxint-1) - 1) mustn't overflow"
-
- if not isinstance(y, long):
- raise TestFailed('int(long(-sys.maxint-1) - 1) should have returned long')
-
-
- class long2(long):
- pass
-
- x = long2(0x1L << 100)
- y = int(x)
- if type(y) is not long:
- raise TestFailed('overflowing int conversion must return long not long subtype')
-
-
-
- def test_auto_overflow():
- import math
- import sys
- if verbose:
- print 'auto-convert int->long on overflow'
-
- special = [
- 0,
- 1,
- 2,
- 3,
- sys.maxint - 1,
- sys.maxint,
- sys.maxint + 1]
- sqrt = int(math.sqrt(sys.maxint))
- special.extend([
- sqrt - 1,
- sqrt,
- sqrt + 1])
- []([ -i for i in special ])
-
- def checkit(*args):
- verify(got == expected, 'for %r expected %r got %r' % (args, expected, got))
-
- for x in special:
- longx = long(x)
- expected = -longx
- got = -x
- checkit('-', x)
- for y in special:
- longy = long(y)
- expected = longx + longy
- got = x + y
- checkit(x, '+', y)
- expected = longx - longy
- got = x - y
- checkit(x, '-', y)
- expected = longx * longy
- got = x * y
- checkit(x, '*', y)
- if abs(y) < 5:
- if x == 0:
- pass
- if not (y < 0):
- expected = longx ** longy
- got = x ** y
- checkit(x, '**', y)
- for z in special:
- if z != 0:
- if y >= 0:
- expected = pow(longx, longy, long(z))
- got = pow(x, y, z)
- checkit('pow', x, y, '%', z)
- else:
-
- try:
- pow(longx, longy, long(z))
- except TypeError:
- None if y else special.extend
- None if y else special.extend
- except:
- None if y else special.extend
-
- raise TestFailed('pow%r should have raised TypeError' % ((longx, longy, long(z)),))
- y >= 0
-
- None if y else special.extend
-
-
-
-
- def test_float_overflow():
- import math
- if verbose:
- print 'long->float overflow'
-
- for x in (-2.0, -1.0, 0.0, 1.0, 2.0):
- verify(float(long(x)) == x)
-
- shuge = '12345' * 120
- huge = 0x1L << 30000
- mhuge = -huge
- namespace = {
- 'huge': huge,
- 'mhuge': mhuge,
- 'shuge': shuge,
- 'math': math }
- for test in [
- 'float(huge)',
- 'float(mhuge)',
- 'complex(huge)',
- 'complex(mhuge)',
- 'complex(huge, 1)',
- 'complex(mhuge, 1)',
- 'complex(1, huge)',
- 'complex(1, mhuge)',
- '1. + huge',
- 'huge + 1.',
- '1. + mhuge',
- 'mhuge + 1.',
- '1. - huge',
- 'huge - 1.',
- '1. - mhuge',
- 'mhuge - 1.',
- '1. * huge',
- 'huge * 1.',
- '1. * mhuge',
- 'mhuge * 1.',
- '1. // huge',
- 'huge // 1.',
- '1. // mhuge',
- 'mhuge // 1.',
- '1. / huge',
- 'huge / 1.',
- '1. / mhuge',
- 'mhuge / 1.',
- '1. ** huge',
- 'huge ** 1.',
- '1. ** mhuge',
- 'mhuge ** 1.',
- 'math.sin(huge)',
- 'math.sin(mhuge)',
- 'math.sqrt(huge)',
- 'math.sqrt(mhuge)',
- 'math.floor(huge)',
- 'math.floor(mhuge)']:
-
- try:
- eval(test, namespace)
- except OverflowError:
- pass
-
- raise TestFailed('expected OverflowError from %s' % test)
- if float(shuge) == int(shuge):
- raise TestFailed('float(shuge) should not equal int(shuge)')
- continue
-
-
-
- def test_logs():
- import math
- if verbose:
- print 'log and log10'
-
- LOG10E = math.log10(math.e)
- for exp in range(10) + [
- 100,
- 1000,
- 10000]:
- value = 10 ** exp
- log10 = math.log10(value)
- verify(fcmp(log10, exp) == 0)
- expected = exp / LOG10E
- log = math.log(value)
- verify(fcmp(log, expected) == 0)
-
- for bad in (-(0x1L << 10000), -0x2L, 0x0L):
-
- try:
- math.log(bad)
- raise TestFailed('expected ValueError from log(<= 0)')
- except ValueError:
- pass
-
-
- try:
- math.log10(bad)
- raise TestFailed('expected ValueError from log10(<= 0)')
- continue
- except ValueError:
- continue
-
-
-
-
-
- def test_mixed_compares():
- import math
- import sys
- if verbose:
- print 'mixed comparisons'
-
-
- class Rat:
-
- def __init__(self, value):
- if isinstance(value, (int, long)):
- self.n = value
- self.d = 1
- elif isinstance(value, float):
- (f, e) = math.frexp(abs(value))
- if not f == 0:
- if f <= f:
- pass
- elif not f < 1.0:
- raise AssertionError
- CHUNK = 28
- top = 0
- while f:
- f = math.ldexp(f, CHUNK)
- digit = int(f)
- if not digit >> CHUNK == 0:
- raise AssertionError
- top = top << CHUNK | digit
- f -= digit
- if f <= f:
- pass
- elif not f < 1.0:
- raise AssertionError
- e -= CHUNK
- if e >= 0:
- n = top << e
- d = 1
- else:
- n = top
- d = 1 << -e
- if value < 0:
- n = -n
-
- self.n = n
- self.d = d
- if not float(n) / float(d) == value:
- raise AssertionError
- else:
- raise TypeError("can't deal with %r" % val)
-
-
- def __cmp__(self, other):
- if not isinstance(other, Rat):
- other = Rat(other)
-
- return cmp(self.n * other.d, self.d * other.n)
-
-
- cases = [
- 0,
- 0.001,
- 0.98999999999999999,
- 1.0,
- 1.5,
- 1e+20,
- 9.9999999999999997e+199]
- for t in (2.0 ** 48, 2.0 ** 50, 2.0 ** 53):
- cases.extend([
- t - 1.0,
- t - 0.29999999999999999,
- t,
- t + 0.29999999999999999,
- t + 1.0,
- long(t - 1),
- long(t),
- long(t + 1)])
-
- cases.extend([
- 0,
- 1,
- 2,
- sys.maxint,
- float(sys.maxint)])
- t = long(9.9999999999999997e+199)
- cases.extend([
- 0x0L,
- 0x1L,
- 0x2L,
- 0x1L << 20000,
- t - 1,
- t,
- t + 1])
- []([ -x for x in cases ])
- for x in cases:
- Rx = Rat(x)
- for y in cases:
- Ry = Rat(y)
- Rcmp = cmp(Rx, Ry)
- xycmp = cmp(x, y)
- if x == y != Rcmp == 0:
- raise TestFailed('%r == %r %d' % (x, y, Rcmp))
-
- if x != y != Rcmp != 0:
- raise TestFailed('%r != %r %d' % (x, y, Rcmp))
-
- if x < y != Rcmp < 0:
- raise TestFailed('%r < %r %d' % (x, y, Rcmp))
-
- if x <= y != Rcmp <= 0:
- raise TestFailed('%r <= %r %d' % (x, y, Rcmp))
-
- if (x > y) != (Rcmp > 0):
- raise TestFailed('%r > %r %d' % (x, y, Rcmp))
-
- if (x >= y) != (Rcmp >= 0):
- raise TestFailed('%r >= %r %d' % (x, y, Rcmp))
- continue
-
-
-
- test_division()
- test_karatsuba()
- test_bitop_identities()
- test_format()
- test_misc()
- test_auto_overflow()
- test_float_overflow()
- test_logs()
- test_mixed_compares()
-